// 一次性执行的云函数：为 username 字段创建唯一索引
// 创建后可以删除此云函数
module.exports = {
	_before: function () {},
	
	/**
	 * 创建 username 唯一索引
	 */
	async createUsernameIndex() {
		const db = uniCloud.database()
		
		try {
			// 第一步：先为所有 username 为 null 或空的用户生成唯一用户名
			console.log('开始处理空用户名...')
			const nullUsernameUsers = await db.collection('uni-id-users')
				.where({
					username: db.command.or([
						db.command.eq(null),
						db.command.eq('')
					])
				})
				.get()
			
			console.log(`找到 ${nullUsernameUsers.data.length} 个空用户名用户`)
			
			// 为空用户名用户生成唯一用户名
			for (const user of nullUsernameUsers.data) {
				const newUsername = `user_${user._id.substring(0, 8)}`
				await db.collection('uni-id-users')
					.doc(user._id)
					.update({
						username: newUsername
					})
				console.log(`已为用户 ${user._id} 设置用户名: ${newUsername}`)
			}
			
			// 第二步：创建唯一索引
			console.log('开始创建唯一索引...')
			const collection = db.collection('uni-id-users')
			
			const result = await collection.createIndex({
				name: 'username_unique',
				fields: [{
					name: 'username',
					type: 1  // 1 表示升序
				}],
				unique: true  // 设置为唯一索引
			})
			
			return {
				errCode: 0,
				errMsg: '用户名唯一索引创建成功',
				data: {
					fixedUsers: nullUsernameUsers.data.length,
					indexResult: result
				}
			}
		} catch (error) {
			console.error('创建索引失败:', error)
			
			// 如果索引已存在，返回友好提示
			if (error.message && error.message.includes('duplicate')) {
				return {
					errCode: -1,
					errMsg: '数据库中仍存在重复的用户名，请先执行 fixDuplicateUsernames 清理',
					error: error.message
				}
			}
			
			if (error.message && error.message.includes('already exists')) {
				return {
					errCode: 0,
					errMsg: '索引已存在，无需重复创建'
				}
			}
			
			return {
				errCode: -1,
				errMsg: '创建索引失败: ' + error.message,
				error
			}
		}
	},
	
	/**
	 * 检查并清理重复的用户名（可选）
	 * 在创建唯一索引前，如果已有重复数据，需要先清理
	 */
	async checkDuplicateUsernames() {
		const db = uniCloud.database()
		const $ = db.command.aggregate
		
		try {
			const duplicates = await db.collection('uni-id-users')
				.aggregate()
				.group({
					_id: '$username',
					count: $.sum(1),
					users: $.push('$$ROOT')
				})
				.match({
					count: $.gt(1)
				})
				.end()
			
			if (duplicates.data.length === 0) {
				return {
					errCode: 0,
					errMsg: '没有发现重复的用户名',
					data: []
				}
			}
			
			return {
				errCode: 0,
				errMsg: `发现 ${duplicates.data.length} 个重复的用户名`,
				data: duplicates.data.map(item => ({
					username: item._id,
					count: item.count,
					users: item.users.map(u => ({
						_id: u._id,
						nickname: u.nickname,
						mobile: u.mobile,
						register_date: u.register_date
					}))
				}))
			}
		} catch (error) {
			console.error('检查重复用户名失败:', error)
			return {
				errCode: -1,
				errMsg: '检查失败: ' + error.message,
				error
			}
		}
	},
	
	/**
	 * 自动修复重复的用户名（为重复的用户名添加后缀）
	 * 保留最早注册的用户原用户名，其他用户添加数字后缀
	 */
	async fixDuplicateUsernames() {
		const db = uniCloud.database()
		const $ = db.command.aggregate
		
		try {
			// 查找重复的用户名
			const duplicates = await db.collection('uni-id-users')
				.aggregate()
				.group({
					_id: '$username',
					count: $.sum(1),
					users: $.push('$$ROOT')
				})
				.match({
					count: $.gt(1)
				})
				.end()
			
			if (duplicates.data.length === 0) {
				return {
					errCode: 0,
					errMsg: '没有发现重复的用户名，无需修复'
				}
			}
			
			const fixedUsers = []
			
			// 处理每组重复的用户名
			for (const group of duplicates.data) {
				const username = group._id
				const users = group.users
				
				// 按注册时间排序，保留最早注册的用户
				users.sort((a, b) => {
					const dateA = a.register_date || 0
					const dateB = b.register_date || 0
					return dateA - dateB
				})
				
				// 从第二个用户开始，为其用户名添加后缀
				for (let i = 1; i < users.length; i++) {
					const user = users[i]
					const newUsername = `${username}${i + 1}`
					
					// 更新用户名
					await db.collection('uni-id-users')
						.doc(user._id)
						.update({
							username: newUsername
						})
					
					fixedUsers.push({
						userId: user._id,
						oldUsername: username,
						newUsername: newUsername
					})
				}
			}
			
			return {
				errCode: 0,
				errMsg: `成功修复 ${fixedUsers.length} 个重复的用户名`,
				data: fixedUsers
			}
		} catch (error) {
			console.error('修复重复用户名失败:', error)
			return {
				errCode: -1,
				errMsg: '修复失败: ' + error.message,
				error
			}
		}
	}
}
